/* Internal signal emissions */
static void gtk_cell_area_editing_started (GtkCellArea *area,
GtkCellRenderer *renderer,
- GtkCellEditable *editable);
+ GtkCellEditable *editable,
+ GdkRectangle *cell_area);
static void gtk_cell_area_editing_canceled (GtkCellArea *area,
GtkCellRenderer *renderer);
static void gtk_cell_area_editing_done (GtkCellArea *area,
G_SIGNAL_RUN_FIRST,
0, /* No class closure here */
NULL, NULL,
- _gtk_marshal_VOID__OBJECT_OBJECT_STRING,
- G_TYPE_NONE, 3,
+ _gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRING,
+ G_TYPE_NONE, 4,
GTK_TYPE_CELL_RENDERER,
GTK_TYPE_CELL_EDITABLE,
+ GDK_TYPE_RECTANGLE,
G_TYPE_STRING);
cell_area_signals[SIGNAL_EDITING_CANCELED] =
static void
gtk_cell_area_editing_started (GtkCellArea *area,
GtkCellRenderer *renderer,
- GtkCellEditable *editable)
+ GtkCellEditable *editable,
+ GdkRectangle *cell_area)
{
g_signal_emit (area, cell_area_signals[SIGNAL_EDITING_STARTED], 0,
- renderer, editable, area->priv->current_path);
+ renderer, editable, cell_area, area->priv->current_path);
}
static void
if (editable_widget != NULL)
{
+ GdkRectangle edit_area;
+
g_return_val_if_fail (GTK_IS_CELL_EDITABLE (editable_widget), FALSE);
gtk_cell_area_set_edited_cell (area, renderer);
gtk_cell_area_set_edit_widget (area, editable_widget);
+
+ gtk_cell_area_aligned_cell_area (area, widget, renderer, &inner_area, &edit_area);
/* Signal that editing started so that callers can get
* a handle on the editable_widget */
- gtk_cell_area_editing_started (area, priv->focus_cell, editable_widget);
+ gtk_cell_area_editing_started (area, priv->focus_cell, editable_widget, &edit_area);
return TRUE;
}
if (priv->edited_cell)
{
+ GtkCellEditable *edit_widget = g_object_ref (priv->edit_widget);
+ GtkCellRenderer *edit_cell = g_object_ref (priv->edited_cell);
+
/* Stop editing of the cell renderer */
gtk_cell_renderer_stop_editing (priv->edited_cell, canceled);
-
+
/* Signal that editing has been canceled */
if (canceled)
gtk_cell_area_editing_canceled (area, priv->edited_cell);
/* Remove any references to the editable widget */
gtk_cell_area_set_edited_cell (area, NULL);
gtk_cell_area_set_edit_widget (area, NULL);
+
+ /* Send the remove-widget signal explicitly (this is done after setting
+ * the edit cell/widget NULL to avoid feedback)
+ */
+ gtk_cell_area_remove_editable (area, edit_cell, edit_widget);
+ g_object_unref (edit_cell);
+ g_object_unref (edit_widget);
}
}
void
gtk_cell_area_inner_cell_area (GtkCellArea *area,
- const GdkRectangle *background_area,
- GdkRectangle *cell_area)
+ const GdkRectangle *cell_area,
+ GdkRectangle *inner_area)
{
GtkCellAreaPrivate *priv;
g_return_if_fail (GTK_IS_CELL_AREA (area));
- g_return_if_fail (background_area != NULL);
g_return_if_fail (cell_area != NULL);
+ g_return_if_fail (inner_area != NULL);
priv = area->priv;
- *cell_area = *background_area;
+ *inner_area = *cell_area;
+
+ inner_area->x += priv->cell_border.left;
+ inner_area->width -= (priv->cell_border.left + priv->cell_border.right);
+ inner_area->y += priv->cell_border.top;
+ inner_area->height -= (priv->cell_border.top + priv->cell_border.bottom);
+}
+
+void
+gtk_cell_area_aligned_cell_area (GtkCellArea *area,
+ GtkWidget *widget,
+ GtkCellRenderer *renderer,
+ const GdkRectangle *cell_area,
+ GdkRectangle *aligned_area)
+{
+ GtkCellAreaPrivate *priv;
+ gint opposite_size, x_offset, y_offset;
+
+ g_return_if_fail (GTK_IS_CELL_AREA (area));
+ g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (cell_area != NULL);
+ g_return_if_fail (aligned_area != NULL);
+
+ priv = area->priv;
+
+ *aligned_area = *cell_area;
+
+ /* Trim up the aligned size */
+ if (gtk_cell_renderer_get_request_mode (renderer) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
+ {
+ gtk_cell_renderer_get_preferred_height_for_width (renderer, widget,
+ aligned_area->width,
+ NULL, &opposite_size);
+
+ aligned_area->height = MIN (opposite_size, aligned_area->height);
+ }
+ else
+ {
+ gtk_cell_renderer_get_preferred_width_for_height (renderer, widget,
+ aligned_area->height,
+ NULL, &opposite_size);
+
+ aligned_area->width = MIN (opposite_size, aligned_area->width);
+ }
+
+ /* offset the cell position */
+ _gtk_cell_renderer_calc_offset (renderer, cell_area,
+ gtk_widget_get_direction (widget),
+ aligned_area->width,
+ aligned_area->height,
+ &x_offset, &y_offset);
- cell_area->x += priv->cell_border.left;
- cell_area->width -= (priv->cell_border.left + priv->cell_border.right);
- cell_area->y += priv->cell_border.top;
- cell_area->height -= (priv->cell_border.top + priv->cell_border.bottom);
+ aligned_area->x += x_offset;
+ aligned_area->y += y_offset;
}
void
/* Distinguish the inner cell area from the whole requested area including margins */
void gtk_cell_area_inner_cell_area (GtkCellArea *area,
const GdkRectangle *cell_area,
- GdkRectangle *inner_cell_area);
+ GdkRectangle *inner_area);
+
+/* Aligns a cell renderer into cell_area by requesting it's size ... used for focus and cell edit areas */
+void gtk_cell_area_aligned_cell_area (GtkCellArea *area,
+ GtkWidget *widget,
+ GtkCellRenderer *renderer,
+ const GdkRectangle *cell_area,
+ GdkRectangle *aligned_area);
+
/* Request the size of a cell while respecting the cell margins (requests are margin inclusive) */
void gtk_cell_area_request_renderer (GtkCellArea *area,
GtkCellAreaBoxIter *box_iter = GTK_CELL_AREA_BOX_ITER (iter);
GSList *allocated_cells, *l;
GdkRectangle cell_background, inner_area;
- GtkAllocation allocation;
gint event_x, event_y;
- gtk_widget_get_allocation (widget, &allocation);
-
/* We may need some semantics to tell us the offset of the event
* window we are handling events for (i.e. GtkTreeView has a bin_window) */
event_x = button_event->x;
{
AllocatedCell *cell = l->data;
GtkCellRendererState cell_fields = 0;
+ GdkRectangle render_background;
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
*/
gtk_cell_area_inner_cell_area (area, &cell_background, &inner_area);
- /* Here after getting the inner area of the cell background,
- * add portions of the background area to the cell background */
+ /* Add portions of the background_area to the cell_background
+ * to create the render_background */
+ render_background = cell_background;
+
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
if (l == allocated_cells)
{
- cell_background.width += cell_background.x - background_area->x;
- cell_background.x = background_area->x;
+ render_background.width += render_background.x - background_area->x;
+ render_background.x = background_area->x;
}
if (l->next == NULL)
- cell_background.width =
- background_area->width - (cell_background.x - background_area->x);
+ render_background.width =
+ background_area->width - (render_background.x - background_area->x);
- cell_background.y = background_area->y;
- cell_background.height = background_area->height;
+ render_background.y = background_area->y;
+ render_background.height = background_area->height;
}
else
{
if (l == allocated_cells)
{
- cell_background.height += cell_background.y - background_area->y;
- cell_background.y = background_area->y;
+ render_background.height += render_background.y - background_area->y;
+ render_background.y = background_area->y;
}
if (l->next == NULL)
- cell_background.height =
- background_area->height - (cell_background.y - background_area->y);
+ render_background.height =
+ background_area->height - (render_background.y - background_area->y);
- cell_background.x = background_area->x;
- cell_background.width = background_area->width;
+ render_background.x = background_area->x;
+ render_background.width = background_area->width;
}
if (focus_cell &&
if (paint_focus)
{
GdkRectangle cell_focus;
- gint opposite_size, x_offset, y_offset;
-
- cell_focus = inner_area;
-
- /* Trim up the focus size */
- if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
- {
- gtk_cell_renderer_get_preferred_height_for_width (cell->renderer, widget,
- cell_focus.width,
- NULL, &opposite_size);
-
- cell_focus.height = MIN (opposite_size, cell_focus.height);
- }
- else
- {
- gtk_cell_renderer_get_preferred_width_for_height (cell->renderer, widget,
- cell_focus.height,
- NULL, &opposite_size);
-
- cell_focus.width = MIN (opposite_size, cell_focus.width);
- }
-
- /* offset the cell position */
- _gtk_cell_renderer_calc_offset (cell->renderer, &inner_area, GTK_TEXT_DIR_LTR,
- cell_focus.width, cell_focus.height,
- &x_offset, &y_offset);
- cell_focus.x += x_offset;
- cell_focus.y += y_offset;
+ gtk_cell_area_aligned_cell_area (area, widget, cell->renderer, &inner_area, &cell_focus);
/* Accumulate the focus rectangle for all focus siblings */
if (first_focus_cell)
/* We have to do some per-cell considerations for the 'flags'
* for focus handling */
gtk_cell_renderer_render (cell->renderer, cr, widget,
- &cell_background, &inner_area,
+ &render_background, &inner_area,
flags | cell_fields);
}
VOID:OBJECT,STRING
VOID:OBJECT,OBJECT,STRING
VOID:OBJECT,OBJECT,OBJECT
+VOID:OBJECT,OBJECT,BOXED,STRING
VOID:POINTER
VOID:POINTER,INT
VOID:POINTER,BOOLEAN
static gboolean cell_area_scaffold_button_press (GtkWidget *widget,
GdkEventButton *event);
+/* GtkContainerClass */
+static void cell_area_scaffold_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
+static void cell_area_scaffold_remove (GtkContainer *container,
+ GtkWidget *child);
+static void cell_area_scaffold_put_edit_widget (CellAreaScaffold *scaffold,
+ GtkWidget *edit_widget,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
/* CellAreaScaffoldClass */
static void cell_area_scaffold_activate (CellAreaScaffold *scaffold);
GtkCellRenderer *renderer,
const gchar *path,
CellAreaScaffold *scaffold);
+static void editing_started_cb (GtkCellArea *area,
+ GtkCellRenderer *renderer,
+ GtkCellEditable *edit_widget,
+ GdkRectangle *cell_area,
+ const gchar *path,
+ CellAreaScaffold *scaffold);
+static void remove_editable_cb (GtkCellArea *area,
+ GtkCellRenderer *renderer,
+ GtkCellEditable *edit_widget,
+ CellAreaScaffold *scaffold);
static void row_changed_cb (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
CellAreaScaffold *scaffold);
-static void row_inserted_cb (GtkTreeModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- CellAreaScaffold *scaffold);
-static void row_deleted_cb (GtkTreeModel *model,
- GtkTreePath *path,
- CellAreaScaffold *scaffold);
-static void rows_reordered_cb (GtkTreeModel *model,
- GtkTreePath *parent,
- GtkTreeIter *iter,
- gint *new_order,
- CellAreaScaffold *scaffold);
+static void row_inserted_cb (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ CellAreaScaffold *scaffold);
+static void row_deleted_cb (GtkTreeModel *model,
+ GtkTreePath *path,
+ CellAreaScaffold *scaffold);
+static void rows_reordered_cb (GtkTreeModel *model,
+ GtkTreePath *parent,
+ GtkTreeIter *iter,
+ gint *new_order,
+ CellAreaScaffold *scaffold);
typedef struct {
gint size; /* The size of the row in the scaffold's opposing orientation */
* we need to queue a redraw */
gulong size_changed_id;
-
+ /* Currently edited widget */
+ GtkWidget *edit_widget;
+ GdkRectangle edit_rect;
+ gulong editing_started_id;
+ gulong remove_editable_id;
};
enum {
(dir) == GTK_DIR_LEFT ? "left" : \
(dir) == GTK_DIR_RIGHT ? "right" : "invalid")
-G_DEFINE_TYPE_WITH_CODE (CellAreaScaffold, cell_area_scaffold, GTK_TYPE_WIDGET,
+G_DEFINE_TYPE_WITH_CODE (CellAreaScaffold, cell_area_scaffold, GTK_TYPE_CONTAINER,
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
gtk_widget_set_has_window (GTK_WIDGET (scaffold), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (scaffold), TRUE);
+ priv->size_changed_id =
+ g_signal_connect (priv->iter, "notify",
+ G_CALLBACK (size_changed_cb), scaffold);
+
priv->focus_changed_id =
g_signal_connect (priv->area, "focus-changed",
G_CALLBACK (focus_changed_cb), scaffold);
- priv->size_changed_id =
- g_signal_connect (priv->iter, "notify",
- G_CALLBACK (size_changed_cb), scaffold);
+ priv->editing_started_id =
+ g_signal_connect (priv->area, "editing-started",
+ G_CALLBACK (editing_started_cb), scaffold);
+
+ priv->remove_editable_id =
+ g_signal_connect (priv->area, "remove-editable",
+ G_CALLBACK (remove_editable_cb), scaffold);
+
+
}
static void
cell_area_scaffold_class_init (CellAreaScaffoldClass *class)
{
- GObjectClass *gobject_class;
- GtkWidgetClass *widget_class;
+ GObjectClass *gobject_class;
+ GtkWidgetClass *widget_class;
+ GtkContainerClass *container_class;
- gobject_class = G_OBJECT_CLASS(class);
+ gobject_class = G_OBJECT_CLASS (class);
gobject_class->dispose = cell_area_scaffold_dispose;
gobject_class->finalize = cell_area_scaffold_finalize;
gobject_class->get_property = cell_area_scaffold_get_property;
gobject_class->set_property = cell_area_scaffold_set_property;
- widget_class = GTK_WIDGET_CLASS(class);
+ widget_class = GTK_WIDGET_CLASS (class);
widget_class->realize = cell_area_scaffold_realize;
widget_class->unrealize = cell_area_scaffold_unrealize;
widget_class->draw = cell_area_scaffold_draw;
widget_class->focus = cell_area_scaffold_focus;
widget_class->button_press_event = cell_area_scaffold_button_press;
+ container_class = GTK_CONTAINER_CLASS (class);
+ container_class->forall = cell_area_scaffold_forall;
+ container_class->remove = cell_area_scaffold_remove;
+
class->activate = cell_area_scaffold_activate;
g_object_class_override_property (gobject_class, PROP_ORIENTATION, "orientation");
{
/* Disconnect signals */
g_signal_handler_disconnect (priv->area, priv->focus_changed_id);
+ g_signal_handler_disconnect (priv->area, priv->editing_started_id);
+ g_signal_handler_disconnect (priv->area, priv->remove_editable_id);
g_object_unref (priv->area);
priv->area = NULL;
valid = gtk_tree_model_iter_next (priv->model, &iter);
}
+ /* Draw the edit widget after drawing everything else */
+ GTK_WIDGET_CLASS (cell_area_scaffold_parent_class)->draw (widget, cr);
+
return FALSE;
}
allocation->width,
allocation->height);
+ /* Allocate the child GtkCellEditable widget if one is currently editing a row */
+ if (priv->edit_widget)
+ gtk_widget_size_allocate (priv->edit_widget, &priv->edit_rect);
+
if (!priv->model)
return;
/* Cache the per-row sizes and allocate the iter */
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
- get_row_sizes (scaffold, priv->row_data, allocation->width);
gtk_cell_area_iter_allocate_width (priv->iter, allocation->width);
+ get_row_sizes (scaffold, priv->row_data, allocation->width);
}
else
{
- get_row_sizes (scaffold, priv->row_data, allocation->height);
gtk_cell_area_iter_allocate_height (priv->iter, allocation->height);
+ get_row_sizes (scaffold, priv->row_data, allocation->height);
}
}
{
event_area.height = data->size;
- if (event->y >= allocation.y + event_area.y &&
- event->y <= allocation.y + event_area.y + event_area.height)
+ if (event->y >= event_area.y &&
+ event->y <= event_area.y + event_area.height)
{
/* XXX A real implementation would assemble GtkCellRendererState flags here */
gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
{
event_area.width = data->size;
- if (event->x >= allocation.x + event_area.x &&
- event->x <= allocation.x + event_area.x + event_area.width)
+ if (event->x >= event_area.x &&
+ event->x <= event_area.x + event_area.width)
{
/* XXX A real implementation would assemble GtkCellRendererState flags here */
gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
return handled;
}
+
+/*********************************************************
+ * GtkContainerClass *
+ *********************************************************/
+static void
+cell_area_scaffold_put_edit_widget (CellAreaScaffold *scaffold,
+ GtkWidget *edit_widget,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ CellAreaScaffoldPrivate *priv = scaffold->priv;
+
+ priv->edit_rect.x = x;
+ priv->edit_rect.y = y;
+ priv->edit_rect.width = width;
+ priv->edit_rect.height = height;
+ priv->edit_widget = edit_widget;
+
+ gtk_widget_set_parent (edit_widget, GTK_WIDGET (scaffold));
+}
+
+static void
+cell_area_scaffold_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (container);
+ CellAreaScaffoldPrivate *priv = scaffold->priv;
+
+ if (priv->edit_widget)
+ (* callback) (priv->edit_widget, callback_data);
+}
+
+static void
+cell_area_scaffold_remove (GtkContainer *container,
+ GtkWidget *child)
+{
+ CellAreaScaffold *scaffold = CELL_AREA_SCAFFOLD (container);
+ CellAreaScaffoldPrivate *priv = scaffold->priv;
+
+ g_return_if_fail (child == priv->edit_widget);
+
+ gtk_widget_unparent (priv->edit_widget);
+ priv->edit_widget = NULL;
+}
+
/*********************************************************
* CellAreaScaffoldClass *
*********************************************************/
CellAreaScaffoldPrivate *priv = scaffold->priv;
GtkWidget *widget = GTK_WIDGET (scaffold);
GtkTreePath *treepath;
- gboolean found = FALSE;
gint *indices;
if (!priv->model)
gtk_tree_path_free (treepath);
- g_print ("Focus changed signal, new focus row %d\n", priv->focus_row);
-
/* Make sure we have focus now */
if (!gtk_widget_has_focus (widget))
gtk_widget_grab_focus (widget);
gtk_widget_queue_draw (widget);
}
+static void
+editing_started_cb (GtkCellArea *area,
+ GtkCellRenderer *renderer,
+ GtkCellEditable *edit_widget,
+ GdkRectangle *cell_area,
+ const gchar *path,
+ CellAreaScaffold *scaffold)
+{
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation (GTK_WIDGET (scaffold), &allocation);
+
+ cell_area_scaffold_put_edit_widget (scaffold, GTK_WIDGET (edit_widget),
+ allocation.x + cell_area->x,
+ allocation.y + cell_area->y,
+ cell_area->width, cell_area->height);
+
+ gtk_cell_editable_start_editing (edit_widget, NULL);
+ gtk_widget_grab_focus (GTK_WIDGET (edit_widget));
+}
+
+static void
+remove_editable_cb (GtkCellArea *area,
+ GtkCellRenderer *renderer,
+ GtkCellEditable *edit_widget,
+ CellAreaScaffold *scaffold)
+{
+ gtk_container_remove (GTK_CONTAINER (scaffold), GTK_WIDGET (edit_widget));
+}
+
static void
rebuild_and_flush_internals (CellAreaScaffold *scaffold)
{
struct _CellAreaScaffold
{
- GtkWidget widget;
+ GtkContainer widget;
CellAreaScaffoldPrivate *priv;
};
struct _CellAreaScaffoldClass
{
- GtkWidgetClass parent_class;
+ GtkContainerClass parent_class;
void (* activate) (CellAreaScaffold *scaffold);
};
static void
cell_toggled (GtkCellRendererToggle *cell_renderer,
- gchar *path,
+ const gchar *path,
CellAreaScaffold *scaffold)
{
GtkTreeModel *model = cell_area_scaffold_get_model (scaffold);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, FOCUS_COLUMN_CHECK, !active, -1);
}
+static void
+cell_edited (GtkCellRendererToggle *cell_renderer,
+ const gchar *path,
+ const gchar *new_text,
+ CellAreaScaffold *scaffold)
+{
+ GtkTreeModel *model = cell_area_scaffold_get_model (scaffold);
+ GtkTreeIter iter;
+
+ g_print ("Cell edited with new text '%s' !\n", new_text);
+
+ if (!gtk_tree_model_get_iter_from_string (model, &iter, path))
+ return;
+
+ gtk_list_store_set (GTK_LIST_STORE (model), &iter, FOCUS_COLUMN_NAME, new_text, -1);
+}
+
static GtkWidget *
focus_scaffold (void)
{
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, TRUE, FALSE);
gtk_cell_area_attribute_connect (area, renderer, "text", FOCUS_COLUMN_NAME);
- /* Catch signal ... */
+ g_signal_connect (G_OBJECT (renderer), "edited",
+ G_CALLBACK (cell_edited), scaffold);
+
focus_renderer = renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "xalign", 0.0F, NULL);
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, TRUE);
projects / gtk4.git / commitdiff